package com.jmb.apiplatform.service.impl;

import com.jmb.apiplatform.exception.ValidException;
import com.jmb.apiplatform.mapper.ApiTestCaseMapper;
import com.jmb.apiplatform.mapper.ApiTestPreCaseMapper;
import com.jmb.apiplatform.pojo.ApiTestCase;
import com.jmb.apiplatform.pojo.ApiTestPreCase;
import com.jmb.apiplatform.service.ApiTestPreCaseService;
import com.jmb.apiplatform.util.ValidUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@Slf4j
@Service
public class ApiTestPreCaseServiceImpl implements ApiTestPreCaseService {
    @Autowired
    private ApiTestPreCaseMapper apiTestPreCaseMapper;

    @Autowired
    private ApiTestCaseMapper apiTestCaseMapper;
    @Override
    public void saveApiTestPreCase(ApiTestPreCase apiTestPreCase) throws ValidException {
        this.checkDO(apiTestPreCase);
        // 查询一下用例表是否存在
        Integer preCaseId = apiTestPreCase.getPreCaseId();
        ApiTestCase apiTestCase = apiTestCaseMapper.selectCase(preCaseId);
        if (apiTestCase==null){
            String errorMsg = String.format("前置用例编号 [%s] 不存在", preCaseId);
            log.error("前置用例编号不存在");
            throw new ValidException("errorMsg");
        }
        // 校验前置用例合法性
        // todo 需求去除,改成前置用例执行时，跳过前置用例。
        // 插入数据
        Date date = new Date();
        apiTestCase.setCreatedTime(date);
        apiTestCase.setUpdateTime(date);
        apiTestPreCaseMapper.insertPreCase(apiTestPreCase);
    }

    @Override
    public void editApiTestPreCase(ApiTestPreCase apiTestPreCase) throws ValidException {

    }

    /**
     * 查询用例的所有前置用例
     * @param preCaseId 父用例的id
     * @return 用例的所有前置用例
     */
    @Override
    public List<ApiTestPreCase> findApiTestPreCaseId(Integer preCaseId) throws ValidException {
        return apiTestPreCaseMapper.selectPreCaseById(preCaseId);
    }

    /**
     *
     * @param id 删除莫个前置用例
     */
    @Override
    public void removeApiTestPreCase(Integer id) throws ValidException {
        apiTestPreCaseMapper.deletePreCaseId(id);

    }

    /**
     * 删除所有的前置用例
     * @param preCaseId 父用例ID
     */
    @Override
    public void removeApiTestPreCaseByCaseId(Integer preCaseId) throws ValidException {
        apiTestPreCaseMapper.deletePreCaseParentId(preCaseId);

    }

    /**
     * 查询用例的前置用例关联表自增编号集合
     * @param PreId 用例编号
     * @return 前置用例的集合
     */
    @Override
    public List<Integer> findApiTestPreCaseById(Integer PreId) throws ValidException {
        return apiTestPreCaseMapper.selectPreCasePreId(PreId);
    }

    /**
     * 查询用例的前置用例编号集合
     * @param caseId 用例编号
     * @return 前置用例集合
     */

    @Override
    public List<Integer> findApiTestPreCaseByCaseId(Integer caseId)  {
        return apiTestPreCaseMapper.selectPreCaseIdByParentId(caseId);
    }

    /**
     * 递归获取所有前置用例(含前置用例包含的前置用例）集合
     * @param returnResult 用来接收返回数据的集合
     * @param PreCaseId 父用例编号
     * @return 取所有的前置用例（含前置用例包含的前置用例）集合
     */
    @Override
    public List<Integer> recursionPreCase(List<Integer> returnResult, Integer PreCaseId) {
        List<Integer> list = this.findApiTestPreCaseByCaseId(PreCaseId);
        returnResult.addAll(list);
        for (Integer pId : list) {
            List<Integer> l = recursionPreCase(new ArrayList<>(), pId);
            returnResult.addAll(l);
        }
        return returnResult;
    }

    private void checkDO(ApiTestPreCase apiTestCase) throws ValidException {
        ValidUtil.notNUll(apiTestCase.getPreCaseId(), "前置用例编号不能为空");
    }
}
